// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef UI_VIEWS_CONTROLS_NATIVE_NATIVE_VIEW_HOST_H_
#define UI_VIEWS_CONTROLS_NATIVE_NATIVE_VIEW_HOST_H_

#include <string>

#include "base/macros.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/views/view.h"

namespace views {
namespace test {
    class NativeViewHostTestBase;
}

class NativeViewHostWrapper;

// If a NativeViewHost's native view is a Widget, this native window
// property is set on the widget, pointing to the owning NativeViewHost.
extern const char kWidgetNativeViewHostKey[];

// A View type that hosts a gfx::NativeView. The bounds of the native view are
// kept in sync with the bounds of this view as it is moved and sized.
// Under the hood, a platform-specific NativeViewHostWrapper implementation does
// the platform-specific work of manipulating the underlying OS widget type.
class VIEWS_EXPORT NativeViewHost : public View {
public:
    // The NativeViewHost's class name.
    static const char kViewClassName[];

    NativeViewHost();
    ~NativeViewHost() override;

    // Attach a gfx::NativeView to this View. Its bounds will be kept in sync
    // with the bounds of this View until Detach is called.
    //
    // Because native views are positioned in the coordinates of their parent
    // native view, this function should only be called after this View has been
    // added to a View hierarchy hosted within a valid Widget.
    void Attach(gfx::NativeView native_view);

    // Detach the attached native view. Its bounds and visibility will no
    // longer be manipulated by this View. The native view may be destroyed and
    // detached before calling this function, and this has no effect in that case.
    void Detach();

    // Sets a preferred size for the native view attached to this View.
    void SetPreferredSize(const gfx::Size& size);

    // Fast resizing will move the native view and clip its visible region, this
    // will result in white areas and will not resize the content (so scrollbars
    // will be all wrong and content will flow offscreen). Only use this
    // when you're doing extremely quick, high-framerate vertical resizes
    // and don't care about accuracy. Make sure you do a real resize at the
    // end. USE WITH CAUTION.
    void set_fast_resize(bool fast_resize) { fast_resize_ = fast_resize; }
    bool fast_resize() const { return fast_resize_; }

    // Sets the color to paint the background during a resize that involves a
    // clip. This is white by default.
    void set_resize_background_color(SkColor resize_background_color)
    {
        resize_background_color_ = resize_background_color;
    }

    // Value of fast_resize() the last time Layout() was invoked.
    bool fast_resize_at_last_layout() const
    {
        return fast_resize_at_last_layout_;
    }

    // Accessor for |native_view_|.
    gfx::NativeView native_view() const { return native_view_; }

    void NativeViewDestroyed();

    // Overridden from View:
    gfx::Size GetPreferredSize() const override;
    void Layout() override;
    void OnPaint(gfx::Canvas* canvas) override;
    void VisibilityChanged(View* starting_from, bool is_visible) override;
    void OnFocus() override;
    gfx::NativeViewAccessible GetNativeViewAccessible() override;
    gfx::NativeCursor GetCursor(const ui::MouseEvent& event) override;

protected:
    bool GetNeedsNotificationWhenVisibleBoundsChange() const override;
    void OnVisibleBoundsChanged() override;
    void ViewHierarchyChanged(
        const ViewHierarchyChangedDetails& details) override;
    const char* GetClassName() const override;

private:
    friend class test::NativeViewHostTestBase;

    // Detach the native view. |destroyed| is true if the native view is
    // detached because it's being destroyed, or false otherwise.
    void Detach(bool destroyed);

    // Invokes ViewRemoved() on the FocusManager for all the child Widgets of our
    // NativeView. This is used when detaching to ensure the FocusManager doesn't
    // have a reference to a View that is no longer reachable.
    void ClearFocus();

    // The attached native view. There is exactly one native_view_ attached.
    gfx::NativeView native_view_;

    // A platform-specific wrapper that does the OS-level manipulation of the
    // attached gfx::NativeView.
    scoped_ptr<NativeViewHostWrapper> native_wrapper_;

    // The preferred size of this View
    gfx::Size preferred_size_;

    // True if the native view is being resized using the fast method described
    // in the setter/accessor above.
    bool fast_resize_;

    // Value of |fast_resize_| during the last call to Layout.
    bool fast_resize_at_last_layout_;

    // Color to paint in the background while resizing.
    SkColor resize_background_color_;

    DISALLOW_COPY_AND_ASSIGN(NativeViewHost);
};

} // namespace views

#endif // UI_VIEWS_CONTROLS_NATIVE_NATIVE_VIEW_HOST_H_
